1. Écrire une fonction compteur(n, m) qui permet de visualiser les secondes s'écouler entre n et m secondes.

   Par exemple l'appel compteur(10, 15) affiche :

   10 secondes !
11 secondes !
12 secondes !
13 secondes !
14 secondes !
15 secondes !

2. Documenter cette fonction.

3. Ajouter une précondition qui vérifie que n est plus petit que m.

1. Modifier la fonction somme de l'exemple précédent en une fonction somme1 qui renvoie la somme des $n$ premiers entiers naturels.

   Exemple : pour somme1(4) renvoie 6 car $S=0+1+2+3=6$.

2. Modifier la fonction somme de l'exemple précédent en une fonction somme2 qui prend toujours comme paramètre un entier naturel $n$ et renvoie la somme de tous les nombres entiers impairs inférieurs au égaux à $n$.

   Exemple : pour somme2(6) renvoie 9 car $S=1+3+5=9$.

Écrire une procédure table_multiqui reçoit en entrée un nombre entier $n$ compris entre 0 et 10 et affiche en sortie la table de multiplication de ce nombre.

Par exemple, table_multi(5) conduit à l'affichage suivant (la partie centrale n'a pas été reproduite) :

• 0 fois 5 = 0

• 1 fois 5 = 5

• 2 fois 5 = 10

• [...]

• 9 fois 5 = 45

• 10 fois 5 = 50

Rey affronte Kylo. Pendant cette affrontement Kylo inflige des dégâts damage psychique à Rey toutes les secondes pendant times secondes.

1. Écrire une fonction darkSide qui prend en paramètres pdv, damage et times. Cette fonction renvoie le nombre de points de vie pdv de Rey à la fin de l'attaque psychique de Kylo, en sachant qu'à chaque seconde Rey perd une valeur égale à damage et sachant que l'attaque dure times secondes.
   Cette fonction doit afficher chaque seconde de l'attaque le nombre de points de vie de Rey.

   Par exemple :
   darkSide(100, 2 , 1) doit renvoyer 98 après avoir affiché avant un seul texte : "Rey a encore 98 points de vie.".
   darkSide(100, 2 , 5) doit renvoyer 90 après avoir affiché 5 textes successifs : "Rey a encore 98 points de vie.", "Rey a encore 96 points de vie.", "Rey a encore 94 points de vie.", "Rey a encore 92 points de vie." et "Rey a encore 90 points de vie.".

2. Dans cette question, on tient compte de l'affaiblissement de Rey. À chaque seconde les dégâts sont augmentés du nombre de seconde écoulé depuis le début de l'attaque.

   Écrire la fonction darkSide2(pdv, damage, times) qui prend en compte la fatigue psychique de Rey.

   Par exemple : darkSide2(100, 2 , 1) doit renvoyer 97, en effet Rey perd 2 points de dégâts et il s'est écoulé 1 seconde : il subit donc 2+1 points de dégâts. De même, darkSide2(100, 2 , 2) doit renvoyer 93, (2+1 points de dégâts la première seconde et 2+2 points de dégâts la deuxième seconde).

Le but est de réaliser la trace d'exécution de l'algorithme suivant :

pdv = 30
for i in range(3):
    if pdv != 30 :    # "!="" signifie "différent de" 
        pdv = pdv + 10*i
    else : 
        pdv = pdv - 10*i

Vous pouvez utiliser la numérotation suivante des lignes :

1) pdv = 30
2) for i in range(3):
3)     if pdv != 30 :   # "!="" signifie "différent de" 
4)         pdv = pdv + 10*i
5)     else : 
6)         pdv = pdv - 10*i

Compléter le tableau de trace d'exécution ci-dessous en faisant dérouler chaque étape du programme :

pour déterminer quelle est la valeur de la variable pdv en fin d'exécution.

Tester le script ci-dessus pour vérifier qu'il réalise bien ce qui a été annoncé et modifier la chaîne de caractères avec une autre phrase (Vous pouvez aussi rajouter des nombres et des symboles).

1. Que fait le code suivant :

   # -*- coding: utf-8 -*-
   citation = "Je ne cherche pas à connaître les réponses, je cherche à comprendre les questions."
   compteur = 0
   for elt in citation:
       if elt == "e":
           compteur = compteur + 1
   print(compteur)	

2. Transformer le code pour qu'il compte le nombre de i.

1. Écrire une fonction est_dans_liste qui prend en paramètres une liste lst et un entier n et qui renvoie True si l'entier est dans la liste et False sinon.

2. Tester la fonction est_dans_liste, entre autres, est_dans_liste([8, 4, 7, 2, 5, 4], 6) renvoie False et est_dans_liste([8, 4, 7, 2, 5, 4], 4) renvoie True.

3. Proposer au moins deux autres tests pour valider cette fonction. Vous utiliserez la commande assert.

Voici un programme qui permet de représenter le coût en temps du parcours sur un itérable comme range :

# importation des bibliothèques
from time import perf_counter
import matplotlib.pyplot as plt  

# fonction dont le coût moyen est évalué en fonction de n
def somme(n: int) -> int: 
    S = 0 #
    for i in range(n+1):
        S = S + i
    return S

# calcul du coût moyen en temps
def temps() -> list:
    Ly = []
    for i in range(11):
        deb = perf_counter() 
        # 100 répétitions du calcul de la somme pour la même valeur de n
        for j in range(100):
            somme(10000*i)
        Ly.append((perf_counter() - deb)/100)  # calcul du temps moyen pour cette valeur de n
    return Ly

# gestion du graphique
Lx = [10000*i for i in range(11)] # création de la liste des abscisses
Ly = temps() # Les différentes valeurs de Ly correspondront aux ordonnées des points 
plt.clf()
plt.axis([0, 100000, 0, 0.015])    # fenêtre du graphique [x_min, x_max, y_min, y_max]
plt.xlabel("nombre d'entiers additionnées")       # légende de l'axe des abscisses
plt.ylabel('temps moyen nécessaire (en seconde)') # légende de l'axe des ordonnées
plt.title('Coût en temps en fonction du nombre de répétitions')  # titre du graphique
plt.grid()                                # graduation
plt.scatter(Lx, Ly, label='temps moyen')   # nuage de points avec une légende explicative
plt.legend()        # pour faire apparaître la légende explicative précédente
plt.show()          # À ne pas oublier : pour faire apparaître le graphique 
                    

1. Exécuter le programme précédent (dans un jupyter-notebook).

   Normalement, vous verrez apparaître un graphique proche de celui-ci :

   

   Si vous n'avez pas 11 points sur votre graphique, remplacer dans plt.axis([0, 100000, 0, 0.015]) 0.015 par un nombre un peu plus grand (tout dépend du processeur de votre ordinateur).

2. Que pouvez-vous dire quant à la relation liant le temps moyen de calcul et le nombre de répétitions ?

3. Quel est l'ordre de grandeur du temps moyen que prend une opération comme l'addition sur un ordinateur comme le vôtre ?

1. Modifier la fonction somme de l'exemple précédent en une fonction somme1 qui renvoie la somme des $n+1$ premiers entiers naturels.

   Exemple : pour somme1(4) renvoie 10 car $S=0+1+2+3+4=10$.

2. Modifier la fonction somme de l'exemple précédent en une fonction somme2 qui prend toujours comme paramètre un entier naturel non nul $n$ et renvoie la somme de tous les nombres entiers impairs inférieurs ou égaux à $n$.

   Exemple : pour somme2(6) renvoie 9 car $S=1+3+5=9$.

3. Rajouter une précondition pour assurer le bon fonctionnement de somme2.

4. Proposer au moins deux tests pour valider cette fonction.

Une association militant pour la sauvegarde d'une espèce protégée fait appel à un financement participatif. Cette association a besoin de 13500€ pour mener à bien sa campagne annuelle. Elle aimerait savoir combien de jours seront nécessaires pour obtenir la somme de 13500€ en fonction de la somme moyenne recueillie sur le site. Elle fait appel à vous afin que vous lui créiez un programme répondant à la question.

1. Écrire une fonction attendre qui prend comme paramètre d'entrée un flottant montant_moyen_don indiquant le don en moyenne recueilli quotidiennement sur le site et renvoie un entier indiquant le nombre de jours nécessaires pour atteindre 13500€.

2. Proposer des préconditions à cette fonction.

Voici un script utilisant l'intrusion répétitive for permettant d'afficher tous les nombres entiers entre 10 et 99 :

def deux_chiffres() -> None: 
    """fonction, sans paramètre, affiche successivement tous les nombres entiers compris entre 10 et 99""" 
    for nb in range(10,100):
        print(nb)
# exécution de la procédure :
deux_chiffres()

1. Compléter le script suivant utilisant l'instruction répétitive conditionnelle while, script qui doit aussi afficher tous les nombres entiers entre 10 et 99 :

   def deux_chiffres2() -> None: 
       ...
       while ...:
           print(nb)
           ...
   # exécution de la procédure :
   deux_chiffres2()

2. Quelles modifications vous ont permis de remplacer un for par un while ?

On reprend l'exercice qui permettait de savoir si un nombre entier n fait partie d'une liste lst ou non. ( lien vers l'exercice similaire traité avec la boucle for.)

Dans la version avec deux return pour forcer l'arrêt dès que la valeur n est trouvée, on avait trouvé :

def est_dans_liste(lst: list, n: int) -> bool:
    for elt in lst:
        if elt == n :
            return True # Arrêt de la fonction dès qu'un élément de la liste vaut n
    return False        # Ligne atteinte dans le cas où aucun élément de la liste ne vaut n

Plutôt que de balayer la liste lst par les valeurs avec la ligne for elt in lst:, il est possible de balayer le liste par les positions avec la structure for pos in range(len(lst)):.
len(lst) renvoie le nombre d'éléments de la liste lst. Par exemple, si lst = [1, 4, 1, 5, 8, 7], len(lst) vaut 6.
En balayant par les positions, on peut accéder à l'élément de la liste en position pos grâce à l'expression lst[pos], en sachant que la position commence par l'indice 0. Par exemple, si lst = [1, 4, 1, 5, 8, 7], lst[3] vaut 5, le quatrième élément puisque le premier est lst[0].

Ainsi, il est possible de réécrire la fonction est_dans_liste précédente en celle est_dans_liste2 ci-dessous :

def est_dans_liste2(lst: list, n: int) -> bool:
    for pos in range(len(lst)):     # balayage de la liste par les positions
        if lst[pos] == n :          # étude de l'élément en position (=d'indice) pos
            return True             # Arrêt de la fonction dès qu'un élément de la liste vaut n
    return False                    # Ligne atteinte dans le cas où aucun élément de la liste ne vaut n

En inspirant de la fonction def est_dans_liste2, créer une fonction def est_dans_liste3 dans laquelle la boucle for est remplacée par une boucle while.
Exemples de tests :
est_dans_liste3([8, 4, 7, 2, 5, 4], 6) renvoie False.
est_dans_liste3([8, 4, 7, 2, 5, 4], 7) renvoie True.

Votre personnage préféré dispose de 25 pièces d'or. À chaque mission qu'il mène à son terme, il ressort avec un nombre aléatoire entre 0 et 20 pièces d'or supplémentaires.

Écrire une fonction nb_mission(target) qui prend en argument un entier target et qui renvoie le nombre de missions à effectuer pour obtenir un nombre de pièces d'or au moins égal à target.